home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 April: Mac OS SDK / Dev.CD Apr 98 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Universal / Interfaces / PInterfaces / MoviesFormat.p < prev    next >
Encoding:
Text File  |  1998-02-12  |  17.9 KB  |  641 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        MoviesFormat.p
  3.  
  4.      Contains:    QuickTime Interfaces.
  5.  
  6.      Version:    Technology:    QuickTime 3.0
  7.                  Release:    Universal Interfaces 3.1
  8.  
  9.      Copyright:    © 1990-1998 by Apple Computer, Inc., all rights reserved
  10.  
  11.      Bugs?:        Please include the the file and version information (from above) with
  12.                  the problem description.  Developers belonging to one of the Apple
  13.                  developer programs can submit bug reports to:
  14.  
  15.                      devsupport@apple.com
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT MoviesFormat;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __MOVIESFORMAT__}
  28. {$SETC __MOVIESFORMAT__ := 1}
  29.  
  30. {$I+}
  31. {$SETC MoviesFormatIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __MACTYPES__}
  35. {$I MacTypes.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __MOVIES__}
  38. {$I Movies.p}
  39. {$ENDC}
  40.  
  41.  
  42. {$PUSH}
  43. {$ALIGN MAC68K}
  44. {$LibExport+}
  45.  
  46.  
  47. CONST
  48.     kMovieVersion                = 0;                            {  version number of the format here described  }
  49.  
  50. {***************************************
  51. *
  52. *   General Types -
  53. *        These types are used in more than one of the
  54. *        directory types.
  55. *
  56. ***************************************}
  57. { MoviesUserData is the type used for user data in movie and track directories }
  58.  
  59. TYPE
  60.     MoviesUserDataPtr = ^MoviesUserData;
  61.     MoviesUserData = RECORD
  62.         size:                    LONGINT;                                {  size of this user data  }
  63.         udType:                    LONGINT;                                {  type of user data  }
  64.         data:                    SInt8;                                    {  the user data  }
  65.     END;
  66.  
  67.     UserDataAtomPtr = ^UserDataAtom;
  68.     UserDataAtom = RECORD
  69.         size:                    LONGINT;
  70.         atomType:                LONGINT;
  71.         userData:                ARRAY [0..0] OF MoviesUserData;
  72.     END;
  73.  
  74. { MoviesDataDescription tells us where the data for the movie or track lives.
  75.    The data can follow the directory, be in the datafork of the same file as the directory resource,
  76.    be in the resource fork of the same file as the directory resource, be in another file in the
  77.    data fork or resource fork, or require a specific bottleneck to fetch the data. }
  78. {***************************************
  79. *
  80. *   MediaDirectory information -
  81. *        The MediaDirectory is tightly coupled to the data.
  82. *
  83. ***************************************}
  84.  
  85.     SampleDescriptionAtomPtr = ^SampleDescriptionAtom;
  86.     SampleDescriptionAtom = RECORD
  87.         size:                    LONGINT;
  88.         atomType:                LONGINT;                                {  = 'stsd'  }
  89.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  90.         numEntries:                LONGINT;
  91.         sampleDescTable:        ARRAY [0..0] OF SampleDescription;
  92.     END;
  93.  
  94. { TimeToSampleNum maps physical sample time to physical sample number. }
  95.     TimeToSampleNumPtr = ^TimeToSampleNum;
  96.     TimeToSampleNum = RECORD
  97.         sampleCount:            LONGINT;
  98.         sampleDuration:            TimeValue;
  99.     END;
  100.  
  101.     TimeToSampleNumAtomPtr = ^TimeToSampleNumAtom;
  102.     TimeToSampleNumAtom = RECORD
  103.         size:                    LONGINT;
  104.         atomType:                LONGINT;                                {  = 'stts'  }
  105.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  106.         numEntries:                LONGINT;
  107.         timeToSampleNumTable:    ARRAY [0..0] OF TimeToSampleNum;
  108.     END;
  109.  
  110. { SyncSamples is a list of the physical samples which are self contained. }
  111.     SyncSampleAtomPtr = ^SyncSampleAtom;
  112.     SyncSampleAtom = RECORD
  113.         size:                    LONGINT;
  114.         atomType:                LONGINT;                                {  = 'stss'  }
  115.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  116.         numEntries:                LONGINT;
  117.         syncSampleTable:        ARRAY [0..0] OF LONGINT;
  118.     END;
  119.  
  120. { SampleToChunk maps physical sample number to chunk number. }
  121. { same as SampleToChunk, but redundant first sample is removed }
  122.     SampleToChunkPtr = ^SampleToChunk;
  123.     SampleToChunk = RECORD
  124.         firstChunk:                LONGINT;
  125.         samplesPerChunk:        LONGINT;
  126.         sampleDescriptionID:    LONGINT;
  127.     END;
  128.  
  129.     SampleToChunkAtomPtr = ^SampleToChunkAtom;
  130.     SampleToChunkAtom = RECORD
  131.         size:                    LONGINT;
  132.         atomType:                LONGINT;                                {  = 'stsc'  }
  133.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  134.         numEntries:                LONGINT;
  135.         sampleToChunkTable:        ARRAY [0..0] OF SampleToChunk;
  136.     END;
  137.  
  138.     ChunkOffsetAtomPtr = ^ChunkOffsetAtom;
  139.     ChunkOffsetAtom = RECORD
  140.         size:                    LONGINT;
  141.         atomType:                LONGINT;                                {  = 'stco'  }
  142.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  143.         numEntries:                LONGINT;
  144.         chunkOffsetTable:        ARRAY [0..0] OF LONGINT;
  145.     END;
  146.  
  147.     SampleSizeAtomPtr = ^SampleSizeAtom;
  148.     SampleSizeAtom = RECORD
  149.         size:                    LONGINT;
  150.         atomType:                LONGINT;                                {  = 'stsz'  }
  151.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  152.         sampleSize:                LONGINT;
  153.         numEntries:                LONGINT;
  154.         sampleSizeTable:        ARRAY [0..0] OF LONGINT;
  155.     END;
  156.  
  157.     ShadowSyncPtr = ^ShadowSync;
  158.     ShadowSync = RECORD
  159.         fdSampleNum:            LONGINT;
  160.         syncSampleNum:            LONGINT;
  161.     END;
  162.  
  163.     ShadowSyncAtomPtr = ^ShadowSyncAtom;
  164.     ShadowSyncAtom = RECORD
  165.         size:                    LONGINT;
  166.         atomType:                LONGINT;                                {  = 'stsz'  }
  167.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  168.         numEntries:                LONGINT;
  169.         shadowSyncTable:        ARRAY [0..0] OF ShadowSync;
  170.     END;
  171.  
  172.     SampleTableAtomPtr = ^SampleTableAtom;
  173.     SampleTableAtom = RECORD
  174.         size:                    LONGINT;
  175.         atomType:                LONGINT;                                {  = 'stbl'  }
  176.         sampleDescription:        SampleDescriptionAtom;
  177.         timeToSampleNum:        TimeToSampleNumAtom;
  178.         sampleToChunk:            SampleToChunkAtom;
  179.         syncSample:                SyncSampleAtom;
  180.         sampleSize:                SampleSizeAtom;
  181.         chunkOffset:            ChunkOffsetAtom;
  182.         shadowSync:                ShadowSyncAtom;
  183.     END;
  184.  
  185.     PublicHandlerInfoPtr = ^PublicHandlerInfo;
  186.     PublicHandlerInfo = RECORD
  187.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  188.         componentType:            LONGINT;
  189.         componentSubType:        LONGINT;
  190.         componentManufacturer:    LONGINT;
  191.         componentFlags:            LONGINT;
  192.         componentFlagsMask:        LONGINT;
  193.         componentName:            SInt8;
  194.     END;
  195.  
  196.     HandlerAtomPtr = ^HandlerAtom;
  197.     HandlerAtom = RECORD
  198.         size:                    LONGINT;
  199.         atomType:                LONGINT;                                {  = 'hdlr'  }
  200.         hInfo:                    PublicHandlerInfo;
  201.     END;
  202.  
  203. { a data reference is a private structure }
  204.     DataRefAtom                            = LONGINT;
  205.     DataInfoAtomPtr = ^DataInfoAtom;
  206.     DataInfoAtom = RECORD
  207.         size:                    LONGINT;
  208.         atomType:                LONGINT;                                {  = 'dinf'  }
  209.         dataRef:                DataRefAtom;
  210.     END;
  211.  
  212.     RgnAtomPtr = ^RgnAtom;
  213.     RgnAtom = RECORD
  214.         size:                    LONGINT;
  215.         atomType:                LONGINT;
  216.         rgnSize:                INTEGER;
  217.         rgnBBox:                Rect;
  218.         data:                    SInt8;
  219.     END;
  220.  
  221.     MatteCompressedAtomPtr = ^MatteCompressedAtom;
  222.     MatteCompressedAtom = RECORD
  223.         size:                    LONGINT;
  224.         atomType:                LONGINT;
  225.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  226.         matteImageDescription:    ImageDescription;
  227.         matteData:                SInt8;
  228.     END;
  229.  
  230.     MatteAtomPtr = ^MatteAtom;
  231.     MatteAtom = RECORD
  232.         size:                    LONGINT;
  233.         atomType:                LONGINT;
  234.         aCompressedMatte:        MatteCompressedAtom;
  235.     END;
  236.  
  237.     ClippingAtomPtr = ^ClippingAtom;
  238.     ClippingAtom = RECORD
  239.         size:                    LONGINT;
  240.         atomType:                LONGINT;
  241.         aRgnClip:                RgnAtom;
  242.     END;
  243.  
  244. {**********************
  245. * Media Info Example Structures
  246. **********************}
  247.  
  248.     VideoMediaInfoHeaderPtr = ^VideoMediaInfoHeader;
  249.     VideoMediaInfoHeader = RECORD
  250.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  251.         graphicsMode:            INTEGER;                                {  for QD - transfer mode  }
  252.         opColorRed:                INTEGER;                                {  opcolor for transfer mode  }
  253.         opColorGreen:            INTEGER;
  254.         opColorBlue:            INTEGER;
  255.     END;
  256.  
  257.     VideoMediaInfoHeaderAtomPtr = ^VideoMediaInfoHeaderAtom;
  258.     VideoMediaInfoHeaderAtom = RECORD
  259.         size:                    LONGINT;                                {  size of Media info  }
  260.         atomType:                LONGINT;                                {  = 'vmhd'  }
  261.         vmiHeader:                VideoMediaInfoHeader;
  262.     END;
  263.  
  264.     VideoMediaInfoPtr = ^VideoMediaInfo;
  265.     VideoMediaInfo = RECORD
  266.         size:                    LONGINT;                                {  size of Media info  }
  267.         atomType:                LONGINT;                                {  = 'minf'  }
  268.         header:                    VideoMediaInfoHeaderAtom;
  269.         dataHandler:            HandlerAtom;
  270.         dataInfo:                DataInfoAtom;
  271.         sampleTable:            SampleTableAtom;
  272.     END;
  273.  
  274.     SoundMediaInfoHeaderPtr = ^SoundMediaInfoHeader;
  275.     SoundMediaInfoHeader = RECORD
  276.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  277.         balance:                INTEGER;
  278.         rsrvd:                    INTEGER;
  279.     END;
  280.  
  281.     SoundMediaInfoHeaderAtomPtr = ^SoundMediaInfoHeaderAtom;
  282.     SoundMediaInfoHeaderAtom = RECORD
  283.         size:                    LONGINT;                                {  size of Media info  }
  284.         atomType:                LONGINT;                                {  = 'vmhd'  }
  285.         smiHeader:                SoundMediaInfoHeader;
  286.     END;
  287.  
  288.     SoundMediaInfoPtr = ^SoundMediaInfo;
  289.     SoundMediaInfo = RECORD
  290.         size:                    LONGINT;                                {  size of Media info  }
  291.         atomType:                LONGINT;                                {  = 'minf'  }
  292.         header:                    SoundMediaInfoHeaderAtom;
  293.         dataHandler:            HandlerAtom;
  294.         dataReference:            DataRefAtom;
  295.         sampleTable:            SampleTableAtom;
  296.     END;
  297.  
  298. { whatever data the media handler needs goes after the atomType }
  299.     MediaInfoPtr = ^MediaInfo;
  300.     MediaInfo = RECORD
  301.         size:                    LONGINT;
  302.         atomType:                LONGINT;
  303.     END;
  304.  
  305. {**********************
  306. * Media Directory Structures
  307. **********************}
  308.     MediaHeaderPtr = ^MediaHeader;
  309.     MediaHeader = RECORD
  310.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  311.         creationTime:            LONGINT;                                {  seconds since Jan 1904 when directory was created  }
  312.         modificationTime:        LONGINT;                                {  seconds since Jan 1904 when directory was appended  }
  313.         timeScale:                TimeValue;                                {  start time for Media (Media time)  }
  314.         duration:                TimeValue;                                {  length of Media (Media time)  }
  315.         language:                INTEGER;
  316.         quality:                INTEGER;
  317.     END;
  318.  
  319.     MediaHeaderAtomPtr = ^MediaHeaderAtom;
  320.     MediaHeaderAtom = RECORD
  321.         size:                    LONGINT;
  322.         atomType:                LONGINT;
  323.         header:                    MediaHeader;
  324.     END;
  325.  
  326.     MediaDirectoryPtr = ^MediaDirectory;
  327.     MediaDirectory = RECORD
  328.         size:                    LONGINT;
  329.         atomType:                LONGINT;                                {  = 'mdia'  }
  330.         mediaHeader:            MediaHeaderAtom;                        {  standard Media information  }
  331.         mediaHandler:            HandlerAtom;
  332.         mediaInfo:                MediaInfo;
  333.     END;
  334.  
  335. {**********************
  336. * Track Structures
  337. **********************}
  338.  
  339. CONST
  340.     TrackEnable                    = $01;
  341.     TrackInMovie                = $02;
  342.     TrackInPreview                = $04;
  343.     TrackInPoster                = $08;
  344.  
  345.  
  346. TYPE
  347.     TrackHeaderPtr = ^TrackHeader;
  348.     TrackHeader = RECORD
  349.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  350.         creationTime:            LONGINT;                                {  seconds since Jan 1904 when directory was created  }
  351.         modificationTime:        LONGINT;                                {  seconds since Jan 1904 when directory was appended  }
  352.         trackID:                LONGINT;
  353.         reserved1:                LONGINT;
  354.         duration:                TimeValue;                                {  length of track (track time)  }
  355.         reserved2:                LONGINT;
  356.         reserved3:                LONGINT;
  357.         layer:                    INTEGER;
  358.         alternateGroup:            INTEGER;
  359.         volume:                    INTEGER;
  360.         reserved4:                INTEGER;
  361.         matrix:                    MatrixRecord;
  362.         trackWidth:                Fixed;
  363.         trackHeight:            Fixed;
  364.     END;
  365.  
  366.     TrackHeaderAtomPtr = ^TrackHeaderAtom;
  367.     TrackHeaderAtom = RECORD
  368.         size:                    LONGINT;                                {  size of track header  }
  369.         atomType:                LONGINT;                                {  = 'tkhd'  }
  370.         header:                    TrackHeader;
  371.     END;
  372.  
  373.     EditListTypePtr = ^EditListType;
  374.     EditListType = RECORD
  375.         trackDuration:            TimeValue;
  376.         mediaTime:                TimeValue;
  377.         mediaRate:                Fixed;
  378.     END;
  379.  
  380.     EditListAtomPtr = ^EditListAtom;
  381.     EditListAtom = RECORD
  382.         size:                    LONGINT;
  383.         atomType:                LONGINT;                                {  = elst  }
  384.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  385.         numEntries:                LONGINT;
  386.         editListTable:            ARRAY [0..0] OF EditListType;
  387.     END;
  388.  
  389.     EditsAtomPtr = ^EditsAtom;
  390.     EditsAtom = RECORD
  391.         size:                    LONGINT;
  392.         atomType:                LONGINT;                                {  = edts  }
  393.         editList:                EditListAtom;
  394.     END;
  395.  
  396.     TrackLoadSettingsPtr = ^TrackLoadSettings;
  397.     TrackLoadSettings = RECORD
  398.         preloadStartTime:        TimeValue;
  399.         preloadDuration:        TimeValue;
  400.         preloadFlags:            LONGINT;
  401.         defaultHints:            LONGINT;
  402.     END;
  403.  
  404.     TrackLoadSettingsAtomPtr = ^TrackLoadSettingsAtom;
  405.     TrackLoadSettingsAtom = RECORD
  406.         size:                    LONGINT;
  407.         atomType:                LONGINT;                                {  = load  }
  408.         settings:                TrackLoadSettings;
  409.     END;
  410.  
  411.     TrackDirectoryPtr = ^TrackDirectory;
  412.     TrackDirectory = RECORD
  413.         size:                    LONGINT;
  414.         atomType:                LONGINT;                                {  = 'trak'  }
  415.         trackHeader:            TrackHeaderAtom;                        {  standard track information  }
  416.         trackClip:                ClippingAtom;
  417.         edits:                    EditsAtom;
  418.         media:                    MediaDirectory;
  419.         userData:                UserDataAtom;                            {  space for extending with new data types  }
  420.     END;
  421.  
  422. {***************************************
  423. *
  424. *   MovieDirectory -
  425. *        The MovieDirectory is the top level structure which
  426. *        holds the TrackInstance describing where the
  427. *        TrackDirectories are.
  428. *
  429. ***************************************}
  430.     MovieHeaderPtr = ^MovieHeader;
  431.     MovieHeader = RECORD
  432.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  433.         creationTime:            LONGINT;                                {  seconds since Jan 1904 when directory was created  }
  434.         modificationTime:        LONGINT;                                {  seconds since Jan 1904 when directory was appended  }
  435.         timeScale:                TimeValue;                                {  Time specifications  }
  436.         duration:                TimeValue;
  437.         preferredRate:            Fixed;                                    {  rate at which to play this movie  }
  438.         preferredVolume:        INTEGER;                                {  volume to play movie at  }
  439.         reserved1:                INTEGER;
  440.         preferredLong1:            LONGINT;
  441.         preferredLong2:            LONGINT;
  442.         matrix:                    MatrixRecord;
  443.         previewTime:            TimeValue;                                {  time in track the proxy begins (track time)  }
  444.         previewDuration:        TimeValue;                                {  how long the proxy lasts (track time)  }
  445.         posterTime:                TimeValue;                                {  time in track the proxy begins (track time)  }
  446.         selectionTime:            TimeValue;                                {  time in track the proxy begins (track time)  }
  447.         selectionDuration:        TimeValue;                                {  time in track the proxy begins (track time)  }
  448.         currentTime:            TimeValue;                                {  time in track the proxy begins (track time)  }
  449.         nextTrackID:            LONGINT;                                {  next value to use for a TrackID  }
  450.     END;
  451.  
  452.     MovieHeaderAtomPtr = ^MovieHeaderAtom;
  453.     MovieHeaderAtom = RECORD
  454.         size:                    LONGINT;
  455.         atomType:                LONGINT;                                {  = 'mvhd'  }
  456.         header:                    MovieHeader;
  457.     END;
  458.  
  459.     TrackDirectoryEntryPtr = ^TrackDirectoryEntry;
  460.     TrackDirectoryEntry = RECORD
  461.         trackDirectory:            TrackDirectory;                            {  Track directory information  }
  462.     END;
  463.  
  464.     MovieDirectoryPtr = ^MovieDirectory;
  465.     MovieDirectory = RECORD
  466.         size:                    LONGINT;
  467.         atomType:                LONGINT;                                {  = 'moov'  }
  468.         header:                    MovieHeaderAtom;
  469.         movieClip:                ClippingAtom;
  470.                                                                         {  Track Directories  }
  471.         track:                    ARRAY [0..0] OF TrackDirectoryEntry;    {  Track directory information  }
  472.                                                                         {  User data for Movie  }
  473.         userData:                UserDataAtom;                            {  space for user extensions  }
  474.     END;
  475.  
  476. {***************************************
  477. ***************************************}
  478.  
  479. { Movie formats and tags }
  480.  
  481. CONST
  482.                                                                 {  some system defined format IDs  }
  483.     MOVIE_TYPE                    = 'moov';
  484.     TRACK_TYPE                    = 'trak';
  485.     MEDIA_TYPE                    = 'mdia';
  486.     VIDEO_TYPE                    = 'vide';
  487.     SOUND_TYPE                    = 'soun';
  488.  
  489. { atom id's }
  490.     MovieAID                    = 'moov';
  491.     MovieHeaderAID                = 'mvhd';
  492.     ClipAID                        = 'clip';
  493.     RgnClipAID                    = 'crgn';
  494.     MatteAID                    = 'matt';
  495.     MatteCompAID                = 'kmat';
  496.     TrackAID                    = 'trak';
  497.     UserDataAID                    = 'udta';
  498.     TrackHeaderAID                = 'tkhd';
  499.     EditsAID                    = 'edts';
  500.     EditListAID                    = 'elst';
  501.     MediaAID                    = 'mdia';
  502.     MediaHeaderAID                = 'mdhd';
  503.     MediaInfoAID                = 'minf';
  504.     VideoMediaInfoHeaderAID        = 'vmhd';
  505.     SoundMediaInfoHeaderAID        = 'smhd';
  506.     GenericMediaInfoHeaderAID    = 'gmhd';
  507.     GenericMediaInfoAID            = 'gmin';
  508.     DataInfoAID                    = 'dinf';
  509.     DataRefAID                    = 'dref';
  510.     SampleTableAID                = 'stbl';
  511.     STSampleDescAID                = 'stsd';
  512.     STTimeToSampAID                = 'stts';
  513.     STSyncSampleAID                = 'stss';
  514.     STSampleToChunkAID            = 'stsc';
  515.     STShadowSyncAID                = 'stsh';
  516.     HandlerAID                    = 'hdlr';
  517.     STSampleSizeAID                = 'stsz';
  518.     STChunkOffsetAID            = 'stco';
  519.     STChunkOffset64AID            = 'co64';
  520.     STSampleIDAID                = 'stid';
  521.     DataRefContainerAID            = 'drfc';
  522.     TrackReferenceAID            = 'tref';
  523.     ColorTableAID                = 'ctab';
  524.     LoadSettingsAID                = 'load';
  525.     PropertyAtomAID                = 'code';
  526.     InputMapAID                    = 'imap';
  527.     MovieBufferHintsAID            = 'mbfh';
  528.     MovieDataRefAliasAID        = 'mdra';
  529.     SoundLocalizationAID        = 'sloc';
  530.     CompressedMovieAID            = 'cmov';
  531.     CompressedMovieDataAID        = 'cmvd';
  532.     DataCompressionAtomAID        = 'dcom';
  533.     ReferenceMovieRecordAID        = 'rmra';
  534.     ReferenceMovieDescriptorAID    = 'rmda';
  535.     ReferenceMovieDataRefAID    = 'rdrf';
  536.     ReferenceMovieVersionCheckAID = 'rmvc';
  537.     ReferenceMovieDataRateAID    = 'rmdr';
  538.     ReferenceMovieComponentCheckAID = 'rmcd';
  539.     ReferenceMovieQualityAID    = 'rmqu';
  540.  
  541. {  Text ATOM definitions }
  542.  
  543.  
  544. TYPE
  545.     TextBoxAtomPtr = ^TextBoxAtom;
  546.     TextBoxAtom = RECORD
  547.         size:                    LONGINT;
  548.         atomType:                LONGINT;                                {  = 'tbox'  }
  549.         textBox:                Rect;                                    {  New text box (overrides defaultTextBox) }
  550.     END;
  551.  
  552.     HiliteAtomPtr = ^HiliteAtom;
  553.     HiliteAtom = RECORD
  554.         size:                    LONGINT;
  555.         atomType:                LONGINT;                                {  = 'hlit'  }
  556.         selStart:                LONGINT;                                {  hilite selection start character }
  557.         selEnd:                    LONGINT;                                {  hilite selection end character }
  558.     END;
  559.  
  560.     KaraokeRecPtr = ^KaraokeRec;
  561.     KaraokeRec = RECORD
  562.         timeVal:                TimeValue;
  563.         beginHilite:            INTEGER;
  564.         endHilite:                INTEGER;
  565.     END;
  566.  
  567.     KaraokeAtomPtr = ^KaraokeAtom;
  568.     KaraokeAtom = RECORD
  569.         numEntries:                LONGINT;
  570.         karaokeEntries:            ARRAY [0..0] OF KaraokeRec;
  571.     END;
  572.  
  573. {  for ReferenceMovieDataRefRecord.flags }
  574.  
  575. CONST
  576.     kDataRefIsSelfContained        = $01;
  577.  
  578.  
  579. TYPE
  580.     ReferenceMovieDataRefRecordPtr = ^ReferenceMovieDataRefRecord;
  581.     ReferenceMovieDataRefRecord = RECORD
  582.         flags:                    LONGINT;
  583.         dataRefType:            OSType;
  584.         dataRefSize:            LONGINT;
  585.         dataRef:                SInt8;
  586.     END;
  587.  
  588. {  for VersionCheckRecord.checkType }
  589.  
  590. CONST
  591.     kVersionCheckMin            = 0;                            {  val1 is the min. version required }
  592.     kVersionCheckMask            = 1;                            {  (gestalt return value & val2) must == val1 }
  593.  
  594.  
  595. TYPE
  596.     QTAltVersionCheckRecordPtr = ^QTAltVersionCheckRecord;
  597.     QTAltVersionCheckRecord = RECORD
  598.         flags:                    LONGINT;                                {  currently always 0 }
  599.         gestaltTag:                OSType;
  600.         val1:                    UInt32;
  601.         val2:                    UInt32;
  602.         checkType:                INTEGER;
  603.     END;
  604.  
  605. {  some helpful constants for DataRateRecord.dataRate  }
  606.  
  607. CONST
  608.     kDataRate144ModemRate        = 1400;
  609.     kDataRate288ModemRate        = 2800;
  610.     kDataRateISDNRate            = 5600;
  611.     kDataRateDualISDNRate        = 11200;
  612.     kDataRateT1Rate                = 150000;
  613.     kDataRateInfiniteRate        = $7FFFFFFF;
  614.  
  615.  
  616. TYPE
  617.     QTAltDataRateRecordPtr = ^QTAltDataRateRecord;
  618.     QTAltDataRateRecord = RECORD
  619.         flags:                    LONGINT;                                {  currently always 0 }
  620.         dataRate:                LONGINT;
  621.     END;
  622.  
  623.     QTAltComponentCheckRecordPtr = ^QTAltComponentCheckRecord;
  624.     QTAltComponentCheckRecord = RECORD
  625.         flags:                    LONGINT;                                {  currently always 0  }
  626.         cd:                        ComponentDescription;
  627.         minVersion:                UInt32;
  628.     END;
  629.  
  630.  
  631. {$ALIGN RESET}
  632. {$POP}
  633.  
  634. {$SETC UsingIncludes := MoviesFormatIncludes}
  635.  
  636. {$ENDC} {__MOVIESFORMAT__}
  637.  
  638. {$IFC NOT UsingIncludes}
  639.  END.
  640. {$ENDC}
  641.